home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 38 / Amiga Format CD38 (1999-03-15)(Future Publishing)(GB)(Track 1 of 3)[!][issue 1999-04].iso / -seriously_amiga- / misc / felix / source / flxclasses.cpp < prev    next >
C/C++ Source or Header  |  1999-01-25  |  8KB  |  353 lines
  1. //*************************************************************************//
  2. // Filename:    mzclasses.cpp
  3. // Autor:       Christian Taulien of Strange Intelligence
  4. // Purpose:     implementation of the mzclasses
  5. // Creation:    18. März 1998
  6. //*************************************************************************//
  7.  
  8. #include "flxclasses.h"
  9. #include "processcomm.h"
  10. #include "freshlocale.h"
  11.  
  12. #include <string.h>
  13. #include <stdio.h>
  14.  
  15. #include <clib/exec_protos.h>
  16. #include <clib/dos_protos.h>
  17. #include <clib/intuition_protos.h>
  18. #include <clib/utility_protos.h>
  19.  
  20. extern "C" void NewList(struct List *list);
  21.  
  22. char *createNameFromInstance(struct APIInstance *arg_poAPIInstance)
  23. /*S*/
  24. {
  25.   char *name = NULL;
  26.   TRACE("Entry");
  27.  
  28.   if (arg_poAPIInstance->api_Name)
  29.   {      
  30.     ULONG len = strlen(arg_poAPIInstance->api_Name);
  31.     name = new char [len+4];
  32.  
  33.     // if the speicher could be reserviert
  34.     if (name)
  35.     {
  36.       strcpy(name, arg_poAPIInstance->api_Name);
  37.     } // if
  38.   } // if
  39. return name;
  40. }
  41. /*E*/
  42.  
  43. //******************************************************************//
  44. //******************************************************************//
  45. //
  46. //  FLXNodeC
  47. //
  48. //******************************************************************//
  49. //******************************************************************//
  50. FLXNodeC::FLXNodeC(struct APIInstance *arg_poInstance, FLXWatchListC *arg_poWatchList)
  51. /*S*/
  52. {
  53.   TRACE("Konstruktor");
  54.   // init the baseclassmembers
  55.   ln_Succ       = NULL;
  56.   ln_Pred       = NULL;
  57.   ln_Type       = NT_USER;
  58.   ln_Pri        = 0;
  59.  
  60.   // now our members
  61.   m_ulFlags       = FLXMASK_DEFAULT;
  62.   m_poAPIInstance = arg_poInstance;
  63.   ln_Name         = createNameFromInstance(arg_poInstance);
  64.  
  65.   m_poNotifyReq = new struct NotifyRequest;
  66.   if (m_poNotifyReq && arg_poWatchList->getMsgPort())
  67.   {
  68.     memset(m_poNotifyReq, 0, sizeof(struct NotifyRequest));
  69.     m_poNotifyReq->nr_Name     = ln_Name;
  70.     m_poNotifyReq->nr_UserData = (ULONG) this; // to find us
  71.     m_poNotifyReq->nr_Flags    = NRF_SEND_MESSAGE;
  72.     m_poNotifyReq->nr_stuff.nr_Msg.nr_Port = arg_poWatchList->getMsgPort();
  73.     StartNotify(m_poNotifyReq);
  74.   }
  75.   else
  76.   {
  77.     TRACE("Kein Speicher oder kein MessagePort");
  78.   } // if
  79.   TRACE(getFileName());
  80. } // FLXNodeC::FLXNodeC()
  81. /*E*/
  82. FLXNodeC::~FLXNodeC()
  83. /*S*/
  84. {                  
  85.   TRACE("Destruktor");
  86.   TRACE(getFileName());
  87.   // wenn NotifyRequest-Vorhanden
  88.   if (m_poNotifyReq)
  89.   {
  90.     EndNotify(m_poNotifyReq);
  91.     delete m_poNotifyReq;
  92.   } // if
  93.  
  94.   if (ln_Name)
  95.   {
  96.     delete ln_Name;
  97.   } // if
  98.  
  99.   // if the node is in a list
  100.   if (ln_Pred && ln_Succ)
  101.   {
  102.     Remove(this);
  103.   } // if
  104. }
  105. /*E*/
  106. FLXNodeC *FLXNodeC::getNext(void)
  107. /*S*/
  108. {
  109.   TRACE("getNext()");
  110.   if (ln_Succ && ln_Succ->ln_Succ)
  111.   {
  112.     return (FLXNodeC *) ln_Succ;
  113.   } // if
  114.  
  115. return NULL;
  116. }
  117. /*E*/
  118. FLXNodeC *FLXNodeC::getPrev(void)
  119. /*S*/
  120. {
  121.   TRACE("getPrev()");
  122.   if (ln_Pred && ln_Pred->ln_Pred)
  123.   {
  124.     return (FLXNodeC *) ln_Pred;
  125.   } // if
  126.  
  127. return NULL;
  128. }
  129. /*E*/
  130. void FLXNodeC::reloadFile(void)
  131. /*S*/
  132. {
  133.   // wenn Verändert und weder versteckt, noch inaktiv
  134.   if (isModified() && !isHidden() && !isInactive())
  135.   {
  136.     struct EasyStruct request =
  137.     {
  138.       sizeof(struct EasyStruct),
  139.       0,
  140.       0,
  141.       NULL,
  142.       0
  143.     };
  144.     char *buffer = new char [strlen(glob_poCatalog->getString(T_NOTIFYASK))+2];
  145.     if (buffer)
  146.     {
  147.       request.es_Title = glob_poCatalog->getString(T_NOTIFYTITLE);
  148.       request.es_GadgetFormat = glob_poCatalog->getString(T_NOTIFYGADGETS);
  149.       sprintf(buffer, glob_poCatalog->getString(T_NOTIFYASK) ,ln_Name);
  150.       request.es_TextFormat = buffer;
  151.       LONG response = EasyRequestArgs((struct Window *) (m_poAPIInstance->api_Window), &request, NULL, NULL);
  152.       setModified(FALSE);
  153.  
  154.       // wenn reload gewünscht
  155.       if (response==1)
  156.       {
  157.         TRACE("Ok. lade file nach");
  158.         SendeNachricht("remote",
  159.           FelixMessage::FLXMSG_REMOTECMD,
  160.           FLXTAG_REMOTECOMMAND, FLXREMOTECMD_RELOADFILE,
  161.           FLXTAG_FileName, getFileName(),
  162.           TAG_DONE);
  163.       } // if
  164.       delete [] buffer;
  165.     } // if
  166.   } // if
  167. }
  168. /*E*/
  169.  
  170. //******************************************************************//
  171. //******************************************************************//
  172. //
  173. //  FLXWatchListC
  174. //
  175. //******************************************************************//
  176. //******************************************************************//
  177. FLXWatchListC::FLXWatchListC()
  178. /*S*/
  179. {
  180.   TRACE("Konstruktor");
  181.   NewList(this);
  182.   m_poMsgPort = CreateMsgPort();
  183.   if (!m_poMsgPort)
  184.   {   
  185.     TRACE("Kein Speicher");
  186.   } // if
  187.  
  188. } // FLXWatchListC::FLXWatchListC()
  189. /*E*/
  190. FLXWatchListC::~FLXWatchListC()
  191. /*S*/
  192. {
  193.   TRACE("Destruktor");
  194.  
  195.   // wenn die Liste nicht leer ist
  196.   if (!IsListEmpty(this))
  197.   {
  198.     TRACE("Achtung: Liste ist nicht leer!!!");
  199.     FLXNodeC *pNode;
  200.     while (pNode = (FLXNodeC *) RemHead(this))
  201.     {         
  202.       pNode->ln_Succ = NULL;
  203.       pNode->ln_Pred = NULL;
  204.       delete pNode;
  205.     } // while
  206.   } // if
  207.  
  208.   if (m_poMsgPort)
  209.   {
  210.     // Port leeren
  211.     struct Message *pMsg;
  212.     while (pMsg = GetMsg(m_poMsgPort))
  213.     {
  214.       ReplyMsg(pMsg);
  215.     } // while
  216.  
  217.     // Port löschen
  218.     DeleteMsgPort(m_poMsgPort);
  219.   } // if
  220. } // FLXWatchListC::~FLXWacthListC()
  221. /*E*/
  222. BOOL FLXWatchListC::addWatch(struct APIInstance *arg_poInstance)
  223. /*S*/
  224. {
  225.   TRACE("addWatch()");
  226.   TRACE(arg_poInstance->api_Name);
  227.   // neuen Watch erzeugen
  228.   FLXNodeC *poWatch = new FLXNodeC(arg_poInstance, this);
  229.   if (poWatch)
  230.   {
  231.     // hänge diesen in die Liste ein
  232.     AddTail(this, poWatch);
  233.   }
  234.   else
  235.   {
  236.     TRACE("Kein Speicher");
  237.     return FALSE;
  238.   } // if
  239. return TRUE;
  240. }
  241. /*E*/
  242. FLXNodeC *FLXWatchListC::findWatch(struct APIInstance *arg_poInstance)
  243. /*S*/
  244. { 
  245.   TRACE("findWatch()");
  246.   FLXNodeC *pNode = NULL;
  247.   // wenn die Watchliste nicht leer ist
  248.   if (!IsListEmpty(this))
  249.   {
  250.     pNode = (FLXNodeC *) lh_Head;
  251.     do
  252.     {
  253.       if (pNode->m_poAPIInstance == arg_poInstance)
  254.       {
  255.         return pNode;
  256.       } // if
  257.     } while (pNode = pNode->getNext());
  258.   } // if
  259.  
  260. return pNode;
  261. }
  262. /*E*/
  263. FLXNodeC *FLXWatchListC::operator[](int arg_iIndex)
  264. /*S*/
  265. {
  266.   TRACE("ENTRY");
  267.  
  268.   FLXNodeC *pNode = NULL;
  269.  
  270.   // wenn die Watchliste nicht leer ist
  271.   if (!IsListEmpty(this))
  272.   {
  273.     int index = 0;
  274.  
  275.     // hole 1. eintrag
  276.     pNode = (FLXNodeC *) lh_Head;
  277.     do
  278.     {
  279.       // wenn i.ten eintrag erreicht
  280.       if (index == arg_iIndex)
  281.       {
  282.         return pNode;
  283.       } // if
  284.  
  285.       index++;
  286.     } while (pNode = pNode->getNext());
  287.   } // if
  288.  
  289. return pNode;
  290. }
  291. /*E*/
  292. int FLXWatchListC::getSize(void)
  293. /*S*/
  294. {
  295.   TRACE("ENTRY");
  296.   int iSize = 0;
  297.  
  298.   // wenn die Liste nicht leer ist
  299.   if (!IsListEmpty(this))
  300.   {
  301.     // hole 1. Eintrag
  302.     FLXNodeC *pNode = (FLXNodeC *) lh_Head;
  303.     for (iSize=1; pNode = pNode->getNext(); iSize++);
  304.   } // if
  305.  
  306. return iSize;
  307. }
  308. /*E*/
  309. void FLXWatchListC::checkAccess(void)
  310. /*S*/
  311. { 
  312.   FLXNodeC *pNode = NULL;
  313.   if (m_poMsgPort)
  314.   {      
  315.     // geh' alle messages durch und markiere alle veränderten nodes
  316.     struct NotifyMessage *pMsg;
  317.     while (pMsg = (struct NotifyMessage *) GetMsg(m_poMsgPort))
  318.     {
  319.       pNode = NULL;
  320.       ULONG dummy = pMsg->nm_NReq->nr_UserData;
  321.       if (dummy)
  322.       {
  323.         pNode = (FLXNodeC *) dummy;
  324.       } // if
  325.       ReplyMsg((struct Message *) pMsg);
  326.  
  327.       if (pNode)
  328.       { 
  329.         TRACE("try modify");
  330.         // if the node is empfänglich for modification-notifies
  331.         if (!pNode->isInactive())
  332.         {
  333.           TRACE("modify set");
  334.           pNode->setModified(TRUE);
  335.         } // if
  336.       } // if
  337.     } // while
  338.   } // if
  339.  
  340.   // wenn die Watchliste nicht leer ist
  341.   if (!IsListEmpty(this))
  342.   {
  343.     // für jedes modifieziert File...
  344.     pNode = (FLXNodeC *) lh_Head;
  345.     do
  346.     {
  347.       pNode->reloadFile();
  348.     } while (pNode = pNode->getNext());
  349.   } // if
  350. }
  351. /*E*/
  352.  
  353.